{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:33:48.400812400Z",
     "start_time": "2023-09-06T05:33:48.378812700Z"
    }
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install PyVirtualDisplay==3.0\n",
    "    !pip install gymnasium==0.28.1\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 04. Dueling Network\n",
    "\n",
    "[Z. Wang et al., \"Dueling Network Architectures for Deep Reinforcement Learning.\" arXiv preprint arXiv:1511.06581, 2015.](https://arxiv.org/pdf/1511.06581.pdf)\n",
    "\n",
    "The proposed network architecture, which is named *dueling architecture*, explicitly separates the representation of state values and (state-dependent) action advantages. \n",
    "\n",
    "![fig1](https://user-images.githubusercontent.com/14961526/60322956-c2f0b600-99bb-11e9-9ed4-443bd14bc3b0.png)\n",
    "\n",
    "The dueling network automatically produces separate estimates of the state value function and advantage function, without any extra supervision. Intuitively, the dueling architecture can learn which states are (or are not) valuable, without having to learn the effect of each action for each state. This is particularly useful in states where its actions do not affect the environment in any relevant way. \n",
    "\n",
    "The dueling architecture represents both the value $V(s)$ and advantage $A(s, a)$ functions with a single deep model whose output combines the two to produce a state-action value $Q(s, a)$. Unlike in advantage updating, the representation and algorithm are decoupled by construction.\n",
    "\n",
    "$$A^\\pi (s, a) = Q^\\pi (s, a) - V^\\pi (s).$$\n",
    "\n",
    "The value function $V$ measures the how good it is to be in a particular state $s$. The $Q$ function, however, measures the the value of choosing a particular action when in this state. Now, using the definition of advantage, we might be tempted to construct the aggregating module as follows:\n",
    "\n",
    "$$Q(s, a; \\theta, \\alpha, \\beta) = V (s; \\theta, \\beta) + A(s, a; \\theta, \\alpha),$$\n",
    "\n",
    "where $\\theta$ denotes the parameters of the convolutional layers, while $\\alpha$ and $\\beta$ are the parameters of the two streams of fully-connected layers.\n",
    "\n",
    "Unfortunately, the above equation is unidentifiable in the sense that given $Q$ we cannot recover $V$ and $A$ uniquely; for example, there are uncountable pairs of $V$ and $A$ that make $Q$ values to zero. To address this issue of identifiability, we can force the advantage function estimator to have zero advantage at the chosen action. That is, we let the last module of the network implement the forward mapping.\n",
    "\n",
    "$$\n",
    "Q(s, a; \\theta, \\alpha, \\beta) = V (s; \\theta, \\beta) + \\big( A(s, a; \\theta, \\alpha) - \\max_{a' \\in |\\mathcal{A}|} A(s, a'; \\theta, \\alpha) \\big).\n",
    "$$\n",
    "\n",
    "This formula guarantees that we can recover the unique $V$ and $A$, but the optimization is not so stable because the advantages have to compensate any change to the optimal action’s advantage. Due to the reason, an alternative module that replaces the max operator with an average is proposed:\n",
    "\n",
    "$$\n",
    "Q(s, a; \\theta, \\alpha, \\beta) = V (s; \\theta, \\beta) + \\big( A(s, a; \\theta, \\alpha) - \\frac{1}{|\\mathcal{A}|} \\sum_{a'} A(s, a'; \\theta, \\alpha) \\big).\n",
    "$$\n",
    "\n",
    "Unlike the max advantage form, in this formula, the advantages only need to change as fast as the mean, so it increases the stability of optimization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:33:49.794927800Z",
     "start_time": "2023-09-06T05:33:48.400812400Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\18213\\anaconda3\\envs\\Rainbow\\lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output\n",
    "from torch.nn.utils import clip_grad_norm_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "Please see *01.dqn.ipynb* for detailed description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:33:49.839254300Z",
     "start_time": "2023-09-06T05:33:49.794927800Z"
    }
   },
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dueling Network\n",
    "\n",
    "Carefully take a look at advantage and value layers separated from feature layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:33:49.846494200Z",
     "start_time": "2023-09-06T05:33:49.812254500Z"
    }
   },
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        # set common feature layer\n",
    "        self.feature_layer = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        \n",
    "        # 原来是直接使用三个线性层得到模型的输出\n",
    "        \n",
    "        # set advantage layer\n",
    "        self.advantage_layer = nn.Sequential(\n",
    "            nn.Linear(128, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, out_dim),\n",
    "        )\n",
    "\n",
    "        # set value layer\n",
    "        self.value_layer = nn.Sequential(\n",
    "            nn.Linear(128, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 1),\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        feature = self.feature_layer(x)\n",
    "        \n",
    "        value = self.value_layer(feature)\n",
    "        advantage = self.advantage_layer(feature)\n",
    "\n",
    "        # 现在将模型的两个部分得到的输出分别求出，作为模型的输出\n",
    "        q = value + advantage - advantage.mean(dim=-1, keepdim=True)\n",
    "        \n",
    "        return q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DQN + DuelingNet Agent (w/o Double-DQN & PER)\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n",
    "\n",
    "\n",
    "Aside from the dueling network architecture, the authors suggest to use Double-DQN and Prioritized Experience Replay as extra components for better performance. However, we don't implement them to simplify the tutorial. There is only one diffrence between DQNAgent here and the one from *01.dqn.ipynb* and that is the usage of clip_grad_norm_ to prevent gradient exploding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:33:49.847494300Z",
     "start_time": "2023-09-06T05:33:49.837254900Z"
    }
   },
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including\n",
    "                           state, action, reward, next_state, done\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        seed: int,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.seed = seed\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, terminated, truncated, _ = self.env.step(action)\n",
    "        done = terminated or truncated\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        # DuelingNet: we clip the gradients to have their norm less than or equal to 10.\n",
    "        clip_grad_norm_(self.dqn.parameters(), 10.0)\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state, _ = self.env.reset(seed=self.seed)\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self, video_folder: str) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        # for recording a video\n",
    "        naive_env = self.env\n",
    "        self.env = gym.wrappers.RecordVideo(self.env, video_folder=video_folder)\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        # reset\n",
    "        self.env = naive_env\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "\n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        curr_q_value = self.dqn(state).gather(1, action)\n",
    "        next_q_value = self.dqn_target(next_state).max(\n",
    "            dim=1, keepdim=True\n",
    "        )[0].detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "\n",
    "        # calculate dqn loss\n",
    "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
    "\n",
    "        return loss\n",
    "\n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py) and [configurations](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py#L91) of CartPole-v1 from Farama Gymnasium's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:33:49.859493600Z",
     "start_time": "2023-09-06T05:33:49.843493500Z"
    }
   },
   "outputs": [],
   "source": [
    "# environment\n",
    "env = gym.make(\"CartPole-v1\", max_episode_steps=200, render_mode=\"rgb_array\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:33:49.879496700Z",
     "start_time": "2023-09-06T05:33:49.858493600Z"
    }
   },
   "outputs": [],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.cuda.manual_seed(seed)\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:33:50.834263300Z",
     "start_time": "2023-09-06T05:33:49.873499Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 10000\n",
    "memory_size = 1000\n",
    "batch_size = 32\n",
    "target_update = 100\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay, seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 2000x500 with 3 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:34:43.507559100Z",
     "start_time": "2023-09-06T05:34:42.618362800Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\18213\\anaconda3\\envs\\Rainbow\\lib\\site-packages\\gymnasium\\wrappers\\record_video.py:87: UserWarning: \u001B[33mWARN: Overwriting existing videos at C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\dueling folder (try specifying a different `video_folder` for the `RecordVideo` wrapper if this is not desired)\u001B[0m\n",
      "  logger.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\dueling\\rl-video-episode-0.mp4.\n",
      "Moviepy - Writing video C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\dueling\\rl-video-episode-0.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                              "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\dueling\\rl-video-episode-0.mp4\n",
      "score:  113.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "video_folder=\"videos/dueling\"\n",
    "agent.test(video_folder=video_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:34:43.523538700Z",
     "start_time": "2023-09-06T05:34:43.480540500Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<IPython.core.display.HTML object>",
      "text/html": "\n        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\"/>\n        </video>\n        "
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Played: videos/dueling\\rl-video-episode-0.mp4\n"
     ]
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(HTML(\n",
    "        data=\"\"\"\n",
    "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "\n",
    "def show_latest_video(video_folder: str) -> str:\n",
    "    \"\"\"Show the most recently recorded video from video folder.\"\"\"\n",
    "    list_of_files = glob.glob(os.path.join(video_folder, \"*.mp4\"))\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    ipython_show_video(latest_file)\n",
    "    return latest_file\n",
    "\n",
    "\n",
    "latest_file = show_latest_video(video_folder=video_folder)\n",
    "print(\"Played:\", latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "language": "python",
   "display_name": "Python 3 (ipykernel)"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
